package transform

import (
	"fmt"

	"github.com/dop251/goja"
	"github.com/louloulin/dataflare/pkg/core"
)

// TransformProcessor 是一个使用JavaScript转换数据的处理器
type TransformProcessor struct {
	// vm 是JavaScript虚拟机
	vm *goja.Runtime
	// function 是JavaScript函数
	function goja.Callable
}

// NewTransformProcessor 创建一个新的转换处理器
func NewTransformProcessor() (core.Processor, error) {
	return &TransformProcessor{}, nil
}

// Init 初始化处理器
func (p *TransformProcessor) Init(config map[string]interface{}) error {
	// 从配置中获取函数
	functionRaw, ok := config["function"]
	if !ok {
		return fmt.Errorf("function is required")
	}

	functionStr, ok := functionRaw.(string)
	if !ok {
		return fmt.Errorf("function must be a string")
	}

	// 创建JavaScript虚拟机
	p.vm = goja.New()

	// 评估函数
	_, err := p.vm.RunString(functionStr)
	if err != nil {
		return fmt.Errorf("failed to evaluate function: %w", err)
	}

	// 获取process函数
	processValue := p.vm.Get("process")
	if processValue == nil {
		return fmt.Errorf("process function not found")
	}

	// 转换为可调用
	function, ok := goja.AssertFunction(processValue)
	if !ok {
		return fmt.Errorf("process is not a function")
	}

	p.function = function
	return nil
}

// Process 处理数据
func (p *TransformProcessor) Process(data []byte, metadata map[string]string) ([]byte, error) {
	// 解析数据为JSON
	var parsedData interface{}
	err := p.vm.ExportTo(p.vm.ToValue(string(data)), &parsedData)
	if err != nil {
		return nil, fmt.Errorf("failed to parse data: %w", err)
	}

	// 调用函数
	result, err := p.function(goja.Undefined(), p.vm.ToValue(parsedData))
	if err != nil {
		return nil, fmt.Errorf("failed to call function: %w", err)
	}

	// 将结果转换为字符串
	resultStr := result.String()
	if resultStr == "undefined" {
		return nil, fmt.Errorf("function returned undefined")
	}

	return []byte(resultStr), nil
}

// Close 关闭处理器
func (p *TransformProcessor) Close() error {
	// 没有需要关闭的资源
	return nil
}

// 注册处理器
func init() {
	// 注册转换处理器
	core.RegisterProcessor("transform", NewTransformProcessor)
}
